package com.dolphin.aiagentplatform.controller;

import com.dolphin.aiagentplatform.common.BaseResponse;
import com.dolphin.aiagentplatform.model.dto.user.*;
import com.dolphin.aiagentplatform.model.vo.user.UserPageVO;
import com.dolphin.aiagentplatform.model.vo.user.UserVO;
import com.dolphin.aiagentplatform.service.UserService;
import com.dolphin.aiagentplatform.utils.ResponseUtils;
import com.dolphin.aiagentplatform.utils.TokenManager;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import static com.dolphin.aiagentplatform.constant.ResponseCodeConst.*;

/**
 * 用户管理控制器
 * 处理用户注册、登录、个人资料管理等功能
 */
@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {

    @Resource
    private UserService userService;

    @Resource
    private TokenManager tokenManager;

    /**
     * 用户注册
     */
    @PostMapping("/register")
    public BaseResponse<Long> register(
            @RequestBody UserRegisterDTO userRegisterDTO) {
        log.debug("接收到用户注册请求");
        try {
            // 调用Service执行注册逻辑
        Long userId = userService.register(userRegisterDTO);
        if (userId == null || userId <= 0) {
                log.error("用户注册失败，返回的userId无效");
            return ResponseUtils.error(SYSTEM_ERROR, "用户注册失败");
        }
        log.debug("用户注册成功，userId:{}", userId);
        return ResponseUtils.success(userId);
        } catch (Exception e) {
            log.error("用户注册异常", e);
            return ResponseUtils.error(SYSTEM_ERROR, "注册失败：" + e.getMessage());
        }
    }

    /**
     * 用户登录
     */
    @PostMapping("/login")
    public BaseResponse<UserVO> login(
            @RequestBody UserLoginDTO userLoginDTO,
            HttpServletRequest request,
            HttpServletResponse response) {
        log.debug("用户登录请求，账号:{}", userLoginDTO.getAccount());
        try {
            // 调用Service执行登录逻辑
        UserVO userVO = userService.login(userLoginDTO, request, response);
        if (userVO == null) {
            log.error("用户登录失败，账号:{}", userLoginDTO.getAccount());
            return ResponseUtils.error(SYSTEM_ERROR, "用户登录失败");
        }
        log.debug("用户登录成功，userId:{}", userVO.getId());
        return ResponseUtils.success(userVO);
        } catch (Exception e) {
            log.error("用户登录异常", e);
            return ResponseUtils.error(SYSTEM_ERROR, "登录失败：" + e.getMessage());
        }
    }

    /**
     * 用户登出
     */
    @PostMapping("/logout")
    public BaseResponse<Boolean> logout(
            HttpServletRequest request,
            HttpServletResponse response) {
        log.debug("用户登出请求");
        try {
            // 检查用户是否已登录
            UserVO userVO = tokenManager.getLoginUser(request);
            if (userVO != null) {
                // 移除用户会话
                tokenManager.removeUserToken(request, response);
                log.debug("用户登出成功，userId:{}", userVO.getId());
            } else {
                log.debug("用户未登录，无需登出");
            }
            return ResponseUtils.success(true);
        } catch (Exception e) {
            log.error("用户登出异常", e);
            return ResponseUtils.error(SYSTEM_ERROR, "登出失败：" + e.getMessage());
        }
    }

    /**
     * 获取当前登录用户信息
     */
    @GetMapping("/get/info")
    public BaseResponse<UserVO> getUserInfo(
            HttpServletRequest request) {
        log.debug("查询当前登录用户信息");
        try {
            // 获取当前登录用户信息
            UserVO userVO = userService.getLoginUserInfo(request);
            log.debug("查询成功，当前登录用户:{}", userVO.getAccount());
            return ResponseUtils.success(userVO);
        } catch (Exception e) {
            log.error("查询当前登录用户信息失败", e);
            return ResponseUtils.error(NOT_LOGIN_ERROR, "未登录或登录已过期");
        }
    }

    /**
     * 修改密码
     */
    @PostMapping("/update/password")
    public BaseResponse<Boolean> updatePassword(
            @RequestBody UserUpdatePasswordDTO userUpdatePasswordDTO,
            HttpServletRequest request,
            HttpServletResponse response) {
        log.debug("用户修改密码请求");
        try {
            // 调用Service执行密码修改
            Boolean result = userService.updatePassword(userUpdatePasswordDTO, request, response);
            if (!result) {
                log.error("用户修改密码失败");
                return ResponseUtils.error(SYSTEM_ERROR, "密码修改失败，请稍后重试");
            }
            log.debug("用户修改密码成功");
            return ResponseUtils.success(true);
        } catch (Exception e) {
            log.error("用户修改密码异常", e);
            return ResponseUtils.error(PARAMS_ERROR, e.getMessage());
        }
    }

    /**
     * 更新个人资料
     */
    @PostMapping("/update/profile")
    public BaseResponse<UserVO> updateProfile(
            @RequestBody UserUpdateProfileDTO userUpdateProfileDTO,
            HttpServletRequest request) {
        log.debug("用户修改个人资料请求");
        try {
            // 调用Service执行个人资料更新
            UserVO userVO = userService.updateUserProfile(userUpdateProfileDTO, request);
            log.debug("用户修改个人资料成功，userId:{}", userVO.getId());
            return ResponseUtils.success(userVO);
        } catch (Exception e) {
            log.error("用户修改个人资料异常", e);
            return ResponseUtils.error(PARAMS_ERROR, e.getMessage());
        }
    }

    /**
     * 分页查询用户列表（管理员）
     */
    @PostMapping("/list/page")
    public BaseResponse<UserPageVO> listUserByPage(
            @RequestBody UserPageQueryDTO userPageQueryDTO,
            HttpServletRequest request) {
        log.debug("分页查询用户列表请求");
        try {
            // 参数校验
            if (userPageQueryDTO == null) {
                return ResponseUtils.error(PARAMS_ERROR, "查询参数不能为空");
            }

            // 调用Service执行分页查询
            UserPageVO userPageVO = userService.listUserByPage(userPageQueryDTO, request);
            log.debug("分页查询用户列表成功，总记录数:{}", userPageVO.getTotal());
            return ResponseUtils.success(userPageVO);
        } catch (Exception e) {
            log.error("分页查询用户列表异常", e);
            return ResponseUtils.error(PARAMS_ERROR, e.getMessage());
        }
    }

    /**
     * 修改用户角色（管理员）
     */
    @PostMapping("/admin/update/role")
    public BaseResponse<Boolean> updateUserRole(
            @RequestBody UserUpdateRoleDTO userUpdateRoleDTO,
            HttpServletRequest request) {
        log.debug("管理员修改用户角色请求");
        try {
            // 参数校验
            if (userUpdateRoleDTO == null || userUpdateRoleDTO.getUserId() == null || userUpdateRoleDTO.getRole() == null) {
                return ResponseUtils.error(PARAMS_ERROR, "参数不能为空");
            }

            // 调用Service执行角色更新
            Boolean result = userService.updateUserRole(userUpdateRoleDTO, request);
            log.debug("管理员修改用户角色成功，targetUserId:{}, newRole:{}",
                    userUpdateRoleDTO.getUserId(), userUpdateRoleDTO.getRole());
            return ResponseUtils.success(result);
        } catch (Exception e) {
            log.error("管理员修改用户角色异常", e);
            return ResponseUtils.error(PARAMS_ERROR, e.getMessage());
        }
    }

    /**
     * 根据用户ID查询用户信息（管理员）
     */
    @GetMapping("/admin/get/{id}")
    public BaseResponse<UserVO> getUserById(
            @PathVariable("id") Long userId,
            HttpServletRequest request) {
        log.debug("管理员查询用户信息请求，userId:{}", userId);

        // 参数校验
        if (userId == null || userId <= 0) {
            return ResponseUtils.error(PARAMS_ERROR, "用户ID不合法");
        }

        try {
            // 调用Service查询用户信息
            UserVO userVO = userService.getUserById(userId, request);
            log.debug("管理员查询用户成功，targetUserId:{}", userId);
            return ResponseUtils.success(userVO);
        } catch (Exception e) {
            log.error("管理员查询用户异常", e);
            return ResponseUtils.error(PARAMS_ERROR, e.getMessage());
        }
    }

    /**
     * 修改用户状态（管理员）
     */
    @PostMapping("/admin/update/status")
    public BaseResponse<Boolean> updateUserStatus(
            @RequestBody UserUpdateStatusDTO userUpdateStatusDTO,
            HttpServletRequest request) {
        log.debug("管理员更新用户状态请求");

        // 参数校验
        if (userUpdateStatusDTO == null || userUpdateStatusDTO.getUserId() == null) {
            return ResponseUtils.error(PARAMS_ERROR, "参数不能为空");
        }

        try {
            // 调用Service执行状态更新
            Boolean result = userService.updateUserStatus(userUpdateStatusDTO, request);
            String statusDesc = userUpdateStatusDTO.getEnabled() == 1 ? "启用" : "禁用";
            log.debug("管理员{}用户成功，targetUserId:{}", statusDesc, userUpdateStatusDTO.getUserId());
            return ResponseUtils.success(result);
        } catch (Exception e) {
            log.error("管理员更新用户状态异常", e);
            return ResponseUtils.error(PARAMS_ERROR, e.getMessage());
        }
    }

    /**
     * 注销账号
     */
    @PostMapping("/deactivate")
    public BaseResponse<Boolean> deactivateAccount(
            HttpServletRequest request,
            HttpServletResponse response) {
        log.debug("用户申请注销账号请求");
        try {
            // 调用Service执行账号注销
            Boolean result = userService.deactivateAccount(request, response);
            log.debug("用户注销账号成功");
            return ResponseUtils.success(result);
        } catch (Exception e) {
            log.error("用户注销账号异常", e);
            return ResponseUtils.error(PARAMS_ERROR, e.getMessage());
        }
    }
}
